
import {
  getNewCartGoods,
  reqMergeLocalCart, reqFindCartList, reqInsertCart, reqDeleteCart,
  reqUpdateCartSku,
  reqCheckAllCart
} from '@/api/cart'

export default {
  namespaced: true,
  // 模块里面的额 state，需要用函数返回
  state: () => {
    return {
      // 购物车列表
      list: []

    }
  },
  getters: {
    // 计算有效的 商品列表  isEffective = true  stock>0
    effectiveList (state) {
      return state.list.filter(item => item.stock > 0 && item.isEffective)
    },
    // 总数量 getters 里面有四个形参 (state ,getters.rootState, rootGetters)
    effectiveTotal (state, getters) {
      return getters.effectiveList.reduce((sum, item) => sum + item.count, 0)
    },
    // 总钱数
    effectiveTotalPrice (state, getters) {
      return getters.effectiveList.reduce((sum, item) => sum + item.count * item.nowPrice, 0).toFixed(2)
    },
    // 计算无效商品列表
    ineffectiveList (state) {
      return state.list.filter(item => !(item.stock > 0 && item.isEffective))
    },
    // 有效商品的全选按钮
    isAllEffectSelected (state, getters) {
      // 所有的有效商品全选中,才返回true
      return getters.effectiveList.every(item => item.selected === true) && getters.effectiveList.length > 0
    },
    // 已选中的有效商品列表  (无效的商品不去管)
    SelectedList (state, getters) {
      return getters.effectiveList.filter(item => item.selected === true)
    },
    // 已经选中的总数  所有商品的couunt的总和
    selectedAllCounts (state, getters) {
      return getters.SelectedList.reduce((sum, item) => sum + item.count, 0)
    },
    // 已选中商品的总价
    selectedAllPrice (state, getters) {
      return getters.SelectedList.reduce((sum, item) => sum + item.nowPrice * item.count, 0)
    }
  },
  mutations: {
    inserCart (state, goods) {
      // 添加购物车 的逻辑
      // 1.如果有重复数据 ,就直接加数量
      // 2.如果 没有重复数据,就在最前面加一个新商品
      // 3.findIndex找不到 返回-1  找到返回>=0的数字
      const sameIndex = state.list.findIndex(item => item.skuId === goods.skuId)
      // console.log('添加偶无车', sameIndex)
      if (sameIndex >= 0) {
        // 累加
        state.list[sameIndex].count += goods.count
      } else {
        state.list.unshift(goods)
      }
    },
    // 删除购物车商品 根据唯一的skuId查找删除
    deleteCart (state, goods) {
      // 两种方法
      // state.list = state.list.filter(item => item.skuId !== goods.skuId)
      const index = state.list.findIndex(item => item.skuId === goods.skuId)
      state.list.splice(index, 1)
    },
    // 更新
    updateCart (state, goods) {
      const sku = state.list.find(item => item.skuId === goods.skuId)
      sku.isEffective = goods.isEffective
      sku.nowPrice = goods.nowPrice
      sku.stock = goods.stock
    },
    // 单选框
    singleCheck (state, { selected, goods }) {
      const sku = state.list.find(item => item.skuId === goods.skuId)
      sku.selected = selected
    },
    // 全选
    checkEffectAll (state, selected) {
      state.list.forEach(item => {
        if (item.isEffective && item.stock > 0) {
          item.selected = selected
        }
      })
    },
    // 改变数量
    changeCount (state, { num, goods }) {
      const sku = state.list.find(item => item.skuId === goods.skuId)
      sku.count = num
    },
    // 设置list  的mutations
    setList (state, newList) {
      state.list = newList
    }

  },
  actions: {
    // 区分登录 和未登录的状态 通过token去判断  但是token怎么获取
    // console.log('context++++', context)
    // rootState   根路径下的state
    // rootGetters 根路径下的getters
    // console.log(context.rootState.user.profile.token)
    // console.log('assss', context.rootGetters.token)

    // 登录
    // asyncInsertCart (context, goods) {
    //   return new Promise((resolve, reject) => {
    //     // 已登录的  走接口
    //     if (context.rootGetters.token) {
    //       console.log('已经录,走接口请求')
    //       // 异步调用的时候可以通过.then() 处理后续的逻辑
    //     } else {
    //       // 未登录的走本地
    //       context.commit('inserCart', goods)
    //       resolve()
    //     }
    //   })
    // },
    // 登录
    async asyncInsertCart (context, goods) {
      console.log(context.rootGetters.token)
      // 已登录的 走接口
      if (context.rootGetters.token) {
        console.log('已登录,走请求')
        // 异步调用的时候可以通过.then() 处理后续的逻辑 可能会加入成功给用户提示等等的操作
        const { skuId, count } = goods
        await reqInsertCart({ skuId, count })
        await context.dispatch('asyncUpdateCart')
        // console.log(res)
      } else {
        // 未登录走本地
        context.commit('inserCart', goods)
      }
    },
    // 删除购物车商品
    async asyncDeleteCart (context, goods) {
      // 已经的路走接口  context.rootState.user.profile.token
      // 分登陆和未登陆
      if (context.rootGetters.token) {
        // 已登录的删除
        console.log('删除这里已经登录,走请求')
        // 异步调用的时候可以通过.then() 处理后续的逻辑 可能会加入成功给用户提示等等的操作
        await reqDeleteCart([goods.skuId])
        await context.dispatch('asyncUpdateCart')
      } else {
        // 未登陆
        context.commit('deleteCart', goods)
      }
    },
    // 更新  韩天野-vue助教-黑马:    resolve ()代表成功了  await才会继续向下执行

    asyncUpdateCart (context, goods) {
      return new Promise((resolve, reject) => {
        if (context.rootGetters.token) {
          // 异步调用的时候可以通过.then() 处理后续的逻辑 可能会加入成功给用户提示等等的操作
          reqFindCartList().then(res => {
            console.log('res-=-=-=-=-', res)
            context.commit('setList', res.result)
            resolve()
          })
        } else {
          // 未登录 走本地
          // 没有登录的时候 只要刷新页面了就需要更新一下商品信息
          const requestArr = context.state.list.map(item => {
            return getNewCartGoods(item.skuId)
          })
          Promise.all(requestArr).then((values) => {
            values.forEach((obj, index) => {
              context.commit('updateCart', {
                skuId: context.state.list[index].skuId,
                ...obj.result
              })
            })
            console.log('store更新李面的', values)
          })
        }
      })
    },
    // 但选
    async asyncSingleCheck (context, { selected, goods }) {
      // 已登录的 走接口
      if (context.rootGetters.token) {
        console.log('已登录,走请求')
        // 异步调用的时候可以通过.then() 处理后续的逻辑 可能会加入成功给用户提示等等的操作
        await reqUpdateCartSku({
          skuId: goods.skuId,
          selected: selected
        })
        await context.dispatch('asyncUpdateCart')
      } else {
        // 未登录走本地
        context.commit('singleCheck', { selected, goods })
      }
    },
    // 全选
    async asyncCheckEffectAll (context, selected) {
      // 已登录的 走接口
      if (context.rootGetters.token) {
        console.log('已登录,走请求')
        // 异步调用的时候可以通过.then() 处理后续的逻辑 可能会加入成功给用户提示等等的操作
        const skuIds = context.getters.effectiveList.map(item => item.skuId)
        await reqCheckAllCart({
          selected: selected,
          ids: skuIds
        })
        await context.dispatch('asyncUpdateCart')
      } else {
        // 未登陆，本地vuex操作
        context.commit('checkEffectAll', selected)
      }
    },
    // 顶购物车里面的数据变化
    async asyncChangeCount (context, { num, goods }) {
      console.log(context.rootGetters.token)

      // 已登录的 走接口
      if (context.rootGetters.token) {
        console.log('已登录,走请求')
        // 异步调用的时候可以通过.then() 处理后续的逻辑 可能会加入成功给用户提示等等的操作
        // 已登录，发请求 - 异步
        await reqUpdateCartSku({
          skuId: goods.skuId,
          count: num
        })
        await context.dispatch('asyncUpdateCart')
      } else {
        // 未登录走本地
        context.commit('changeCount', { num, goods })
      }
    },
    // 合并
    async asyncMergeLocalCart (context) {
      const cartList = context.state.list.map(({ skuId, selected, count }) => {
        return { skuId, selected, count }
      })
      await reqMergeLocalCart(cartList)
      // 合并成功后,从后端获取最新的购物车列表替换本地

      await context.dispatch('asyncUpdateCart')
    }
  }
}
